package com.FrameWork.Utils;

import com.SFA.R;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.widget.Toast;

/**
 * 提示工具类。包括：等待对话框、Toast提示、消息对话框等等。
 * 
 * @author Steven Jiang
 * @since 2012年6月6日
 */
public class MessageUtils
{
	static class WaitingDialogHandler extends Handler
	{
		private static CharSequence _DialogMessage  = null;

		private static final int    END_WAITING     = 1;

		private static final int    START_WAITING   = 0;

		private static final int    UPDATE_MESSAGE  = 2;

		private static final int    QUIT	    = 3;

		private AlertDialog	 _ProgressDialog = null;

		public WaitingDialogHandler(Context owner, Looper looper)
		{
			super(looper);
			if (_ProgressDialog == null)
			{
				_ProgressDialog = new ProgressDialog(owner);
				_ProgressDialog.setCancelable(false);
			}
		}

		


		public void handleMessage(Message msg)
		{
			switch (msg.what)
			{
			case START_WAITING:
				if (_ProgressDialog != null && _DialogMessage != null)
				{
					this.sendEmptyMessage(UPDATE_MESSAGE);
					_ProgressDialog.show();
					this.sendEmptyMessage(QUIT);
				}
				break;
			case END_WAITING:
				if (_ProgressDialog != null)
				{
					_ProgressDialog.dismiss();
					_ProgressDialog = null;
				}
				break;
			case UPDATE_MESSAGE:
				if (_ProgressDialog != null)
					_ProgressDialog.setMessage(_DialogMessage);
				break;
			case QUIT:
				if (_ProgressDialog == null)
				{
					this.getLooper().quit();
					_LastWaitingDialogHandler = null;
				}
				else
				{
					// 每10秒检测一次。是否停止。检测频率不能太短，
					// 否则会出现Handler{} sending message to a Handler
					// on a dead thread
					this.sendEmptyMessageDelayed(QUIT, 10000);
				}
				break;
			}
		}
	}

	private static Handler _LastWaitingDialogHandler = null;

	public static void showEsureExitDialog(Context owner,
			OnClickListener cancelListener,
			OnClickListener exitListener)
	{
		AlertDialog.Builder builder = new AlertDialog.Builder(owner);
		builder.setIcon(R.drawable.warning);
		builder.setTitle(R.string.info_IsSure2Quit);
		builder.setNegativeButton(R.string.CANCEL, cancelListener);
		builder.setPositiveButton(R.string.EXIT, exitListener);
		builder.show();
	}

	public static void showOkMessageBox(final Activity owner,
			final String title,
			final String message)
	{
		AlertDialog.Builder builder = new AlertDialog.Builder(owner);

		builder.setTitle(title)
		.setMessage(message)
		.setCancelable(false)
		.setPositiveButton("确定", new DialogInterface.OnClickListener()
		{
			public void onClick(DialogInterface dialog, int id)
			{
				dialog.cancel();
			}
		});
		Looper.prepare();
		AlertDialog alert = builder.create();
		alert.show();
	}

	/**
	 * 在新的线程中Toast.MakeText，以便快速响应显示。 UI线程较忙时，使用效果最好。
	 * 
	 * @author Steven Jiang
	 * @param owner
	 * @param message
	 * @param duration
	 *            Toast.LENGTH_LONG 或 Toast.LENGTH_SHORT
	 */
	public static void showToastOnNewThread(final Context owner,
			final CharSequence message,
			final int duration)
	{
		new Thread()
		{
			@Override
			public void run()
			{
				// Toast 显示需要出现在一个线程的消息队列中
				Looper.prepare();
				Handler mHandler = new Handler()
				{
					public void handleMessage(Message msg)
					{
						switch (msg.what)
						{
						case 1:
							Toast.makeText(owner, message, duration).show();
							this.sendEmptyMessageDelayed(2, 5000);
							break;
						case 2:
							Looper.myLooper().quit();
							break;
						}
					}
				};
				mHandler.sendEmptyMessage(1);
				Looper.loop();
			}
		}.start();
	}

	/**
	 * 在新的线程中Toast.MakeText，以便快速响应显示。 UI线程较忙时，使用效果最好。
	 * 
	 * @author Steven Jiang
	 * @param owner
	 * @param resId
	 * @param duration
	 *            Toast.LENGTH_LONG 或 Toast.LENGTH_SHORT
	 */
	public static void showToastOnNewThread(final Context owner,
			final int resId,
			final int duration)
	{
		showToastOnNewThread(owner, owner.getString(resId), duration);
	}

	/**
	 * 在新线程中启动ProgressDialog，以便快速响应显示。UI线程较忙时，使用效果最好。
	 * 
	 * @author Steven Jiang
	 * 
	 * @param 启动等待对话框
	 *            Handler.sendEmptyMessage(MessageUtils.StartWaiting);
	 * @param 停止等待对话框
	 *            Handler.sendEmptyMessage(MessageUtils.EndWaiting);
	 * @return
	 *         【默认会马上启动对话框】
	 */
	public static Handler showWaitingDialogOnNewThread(Context owner,
			CharSequence text)
	{
		return showWaitingDialogOnNewThread(owner, text, true);
	}

	/**
	 * 在新线程中启动ProgressDialog，以便快速响应显示。UI线程较忙时，使用效果最好。
	 * 
	 * @author Steven Jiang
	 * 
	 * @param 启动等待对话框
	 *            Handler.sendEmptyMessage(MessageUtils.StartWaiting);
	 * @param 停止等待对话框
	 *            Handler.sendEmptyMessage(MessageUtils.EndWaiting);
	 * @param startNow
	 *            是否马上启动对话框。否则需手动调用sendEmptyMessage(START_WAITING);
	 * @return
	 *         【默认会马上启动对话框】可以使用返回的Handler控制手动启动。
	 */
	public static Handler showWaitingDialogOnNewThread(Context owner,
			CharSequence text,
			boolean startNow)
	{
		WaitingDialogHandler._DialogMessage = text;

		if (_LastWaitingDialogHandler == null)
		{
			HandlerThread d = new HandlerThread("YE");
			d.start();
			_LastWaitingDialogHandler = new WaitingDialogHandler(owner,
					d.getLooper());
		}
		if (startNow)
		{
			_LastWaitingDialogHandler.sendEmptyMessage(WaitingDialogHandler.START_WAITING);
		}
		return _LastWaitingDialogHandler;
	}

	/**
	 * 在新线程中启动ProgressDialog，以便快速响应显示。UI线程较忙时，使用效果最好。
	 * 
	 * @author Steven Jiang
	 * 
	 * @param 启动等待对话框
	 *            Handler.sendEmptyMessage(MessageUtils.StartWaiting);
	 * @param 停止等待对话框
	 *            Handler.sendEmptyMessage(MessageUtils.EndWaiting);
	 * @return
	 *         【默认会马上启动对话框】
	 */
	public static Handler
	showWaitingDialogOnNewThread(Context owner, int resId)
	{
		return showWaitingDialogOnNewThread(owner, owner.getString(resId), true);
	}

	/**
	 * 可以反复调用设置显示新MessageText。
	 * 
	 * @param text
	 */
	public static void updateWaitingDialogOnNewThread(CharSequence text)
	{
		if (_LastWaitingDialogHandler != null
				&& _LastWaitingDialogHandler.getLooper().getThread().isAlive())
		{
			WaitingDialogHandler._DialogMessage = text;
			_LastWaitingDialogHandler.sendEmptyMessage(WaitingDialogHandler.UPDATE_MESSAGE);
		}
	}

	
	
	
	
}
